// pages/active-report/active-report.js
const app = getApp()

Page({
  data: {
    orders: [],
    orderModels: [],
    selectedOrder: null,
    selectedModel: null,
    quantity: '',
    workHours: '',
    startTime: '',
    endTime: '',
    workDate: '',
    remark: '',
    loading: true,
    submitting: false,
    productItems: [], // 产品编号列表
    images: [] // 通用图片列表
  },

  onLoad() {
    this.loadOrders()
    this.setWorkDate()
  },

  // 设置工作日期为今天
  setWorkDate() {
    const today = new Date()
    const year = today.getFullYear()
    const month = String(today.getMonth() + 1).padStart(2, '0')
    const day = String(today.getDate()).padStart(2, '0')
    this.setData({
      workDate: `${year}-${month}-${day}`
    })
  },

  // 加载订单列表
  loadOrders() {
    console.log('开始加载订单列表')
    app.request({
      url: '/getOrders'
    }).then((res) => {
      console.log('获取订单列表成功:', res)
      this.setData({
        orders: res.data,
        loading: false
      })
    }).catch((err) => {
      console.error('获取订单列表失败:', err)
      this.setData({
        loading: false
      })
      wx.showToast({
        title: '获取订单失败',
        icon: 'none'
      })
    })
  },

  // 订单选择
  onOrderChange(e) {
    console.log('=== 订单选择变化 ===')
    console.log('选择索引:', e.detail.value)
    console.log('所有订单:', this.data.orders)
    
    const orderId = e.detail.value
    const order = this.data.orders[orderId]
    
    console.log('选中的订单:', order)
    console.log('订单ID:', order ? order.id : '无')
    console.log('订单ID类型:', order ? typeof order.id : '无')
    
    this.setData({
      selectedOrder: order,
      selectedModel: null,
      orderModels: []
    })
    
    if (order && order.id) {
      console.log('开始加载订单型号，订单ID:', order.id)
      this.loadOrderModels(order.id)
    } else {
      console.log('订单无效或没有ID，不加载型号')
    }
  },

  // 加载订单型号
  loadOrderModels(orderId) {
    console.log('=== 开始加载订单型号 ===')
    console.log('orderId:', orderId)
    console.log('orderId类型:', typeof orderId)
    
    const requestUrl = '/getOrderModels?order_id=' + orderId
    console.log('请求URL:', requestUrl)
    console.log('完整URL:', app.globalData.baseUrl + requestUrl)
    
    console.log('开始发送请求...')
    app.request({
      url: requestUrl,
      method: 'GET'
    }).then((res) => {
      console.log('=== 获取订单型号成功 ===')
      console.log('响应数据:', res)
      console.log('响应数据类型:', typeof res)
      console.log('响应data:', res.data)
      console.log('响应data类型:', typeof res.data)
      console.log('响应data长度:', Array.isArray(res.data) ? res.data.length : '不是数组')
      
      if (Array.isArray(res.data)) {
        console.log('数据是数组，设置到页面')
        this.setData({
          orderModels: res.data
        })
        console.log('页面数据已更新，orderModels长度:', this.data.orderModels.length)
      } else {
        console.log('数据不是数组，可能是:', res.data)
        wx.showToast({
          title: '数据格式错误',
          icon: 'none'
        })
      }
    }).catch((err) => {
      console.error('=== 获取订单型号失败 ===')
      console.error('错误对象:', err)
      console.error('错误消息:', err.msg)
      console.error('错误代码:', err.code)
      console.error('错误数据:', err.data)
      
      wx.showToast({
        title: err.msg || '获取型号失败',
        icon: 'none'
      })
    })
  },

  // 型号选择
  onModelChange(e) {
    const modelIndex = e.detail.value
    const model = this.data.orderModels[modelIndex]
    
    this.setData({
      selectedModel: model
    })
  },

  // 数量输入
  onQuantityInput(e) {
    const quantity = parseInt(e.detail.value) || 0
    const maxQuantity = this.data.selectedModel ? this.data.selectedModel.order_quantity : 0
    
    // 限制数量不能超过订单数量
    if (quantity > maxQuantity) {
      wx.showToast({
        title: `数量不能超过${maxQuantity}`,
        icon: 'none'
      })
      this.setData({
        quantity: maxQuantity.toString()
      })
      return
    }
    
    this.setData({
      quantity: quantity.toString()
    })
    
    // 生成产品编号列表
    this.generateProductItems(quantity)
  },

  // 工时输入
  onWorkHoursInput(e) {
    this.setData({
      workHours: e.detail.value
    })
  },

  // 开始时间变化
  onStartTimeChange(e) {
    const startTime = e.detail.value
    this.setData({
      startTime: startTime
    })
    
    // 自动计算工时
    this.calculateWorkHours()
  },

  // 结束时间变化
  onEndTimeChange(e) {
    const endTime = e.detail.value
    this.setData({
      endTime: endTime
    })
    
    // 自动计算工时
    this.calculateWorkHours()
  },

  // 自动计算工时
  calculateWorkHours() {
    const { startTime, endTime, workDate } = this.data
    
    if (startTime && endTime && workDate) {
      const start = new Date(`${workDate} ${startTime}`)
      const end = new Date(`${workDate} ${endTime}`)
      
      if (end > start) {
        const hours = (end - start) / (1000 * 60 * 60)
        this.setData({
          workHours: hours.toFixed(2)
        })
      }
    }
  },

  // 工作日期变化
  onWorkDateChange(e) {
    this.setData({
      workDate: e.detail.value
    })
  },

  // 备注输入
  onRemarkInput(e) {
    this.setData({
      remark: e.detail.value
    })
  },

  // 生成产品编号列表
  generateProductItems(quantity) {
    if (!quantity || quantity <= 0) {
      this.setData({
        productItems: []
      })
      return
    }

    const productItems = []
    for (let i = 1; i <= quantity; i++) {
      const itemNo = String(i).padStart(3, '0') // 001, 002, 003...
      productItems.push({
        item_no: itemNo,
        images: [],
        hasImages: false
      })
    }

    this.setData({
      productItems: productItems
    })
  },

  // 选择图片
  chooseImage(e) {
    const itemNo = e.currentTarget.dataset.itemNo
    console.log('选择图片，产品编号:', itemNo)
    
    const productItems = this.data.productItems
    const itemIndex = productItems.findIndex(item => item.item_no === itemNo)
    
    if (itemIndex === -1) {
      console.error('未找到产品编号:', itemNo)
      return
    }
    
    const currentImages = productItems[itemIndex].images
    const remainingCount = 9 - currentImages.length
    
    console.log('当前图片数量:', currentImages.length, '剩余可上传数量:', remainingCount)
    
    if (remainingCount <= 0) {
      wx.showToast({
        title: '已达到最大图片数量',
        icon: 'none'
      })
      return
    }
    
    wx.chooseImage({
      count: remainingCount,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        console.log('选择图片成功:', res.tempFilePaths)
        if (res.tempFilePaths && res.tempFilePaths.length > 0) {
          // 上传图片
          this.uploadImages(res.tempFilePaths, itemNo)
        } else {
          console.error('没有选择到图片文件')
          wx.showToast({
            title: '没有选择到图片',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        console.error('选择图片失败:', err)
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        })
      }
    })
  },

  // 上传图片
  uploadImages(tempFilePaths, itemNo) {
    console.log('开始上传图片，文件路径:', tempFilePaths, '产品编号:', itemNo)
    
    if (!tempFilePaths || tempFilePaths.length === 0) {
      console.error('没有文件路径')
      wx.showToast({
        title: '没有选择文件',
        icon: 'none'
      })
      return
    }
    
    wx.showLoading({
      title: '上传中...'
    })

    const uploadPromises = tempFilePaths.map((filePath, index) => {
      return new Promise((resolve, reject) => {
        console.log(`=== 开始上传第${index + 1}张图片 ===`)
        console.log('图片索引:', index)
        console.log('图片路径:', filePath)
        console.log('总图片数量:', tempFilePaths.length)
        
        wx.uploadFile({
          url: app.globalData.baseUrl + '/uploadImage',
          filePath: filePath,
          name: 'file',
          header: {
            'token': wx.getStorageSync('token')
          },
          success: (res) => {
            console.log(`=== 第${index + 1}张图片上传响应 ===`)
            console.log('响应状态码:', res.statusCode)
            console.log('响应数据:', res.data)
            try {
              const data = JSON.parse(res.data)
              if (data.code === 1) {
                console.log(`=== 第${index + 1}张图片上传成功 ===`)
                console.log('图片URL:', data.data.url)
                console.log('本地URL:', data.data.local_url)
                console.log('云端URL:', data.data.cloud_url)
                console.log('备份信息:', data.data.backup_info)
                console.log('上传状态:', data.data.upload_status)
                console.log('七牛状态:', data.data.qiniu_status)
                resolve(data.data.url)
              } else {
                console.error(`=== 第${index + 1}张图片上传失败 ===`)
                console.error('错误信息:', data.msg)
                console.error('错误代码:', data.code)
                reject(new Error(data.msg))
              }
            } catch (e) {
              console.error(`=== 第${index + 1}张图片响应解析失败 ===`)
              console.error('解析错误:', e)
              console.error('原始响应:', res.data)
              reject(new Error('响应解析失败'))
            }
          },
          fail: (err) => {
            console.error(`第${index + 1}张图片上传失败:`, err)
            reject(err)
          }
        })
      })
    })

    Promise.all(uploadPromises).then(imageUrls => {
      console.log('所有图片上传成功:', imageUrls)
      
      // 更新产品编号的图片列表
      const productItems = this.data.productItems
      const itemIndex = productItems.findIndex(item => item.item_no === itemNo)
      
      if (itemIndex !== -1) {
        productItems[itemIndex].images = [...productItems[itemIndex].images, ...imageUrls]
        productItems[itemIndex].hasImages = productItems[itemIndex].images.length > 0
        
        this.setData({
          productItems: productItems
        })
        
        console.log('更新后的产品项目:', productItems[itemIndex])
      }
      
      wx.hideLoading()
      wx.showToast({
        title: '上传成功',
        icon: 'success'
      })
    }).catch(err => {
      console.error('图片上传失败:', err)
      wx.hideLoading()
      wx.showToast({
        title: '上传失败: ' + (err.message || err.errMsg || '未知错误'),
        icon: 'none',
        duration: 3000
      })
    })
  },

  // 选择通用图片（用于计时报工）
  chooseGeneralImage() {
    const currentImages = this.data.images || []
    const remainingCount = 9 - currentImages.length
    
    console.log('选择通用图片，当前图片数量:', currentImages.length, '剩余可上传数量:', remainingCount)
    
    if (remainingCount <= 0) {
      wx.showToast({
        title: '已达到最大图片数量',
        icon: 'none'
      })
      return
    }
    
    wx.chooseImage({
      count: remainingCount,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera'],
      success: (res) => {
        console.log('选择通用图片成功:', res.tempFilePaths)
        if (res.tempFilePaths && res.tempFilePaths.length > 0) {
          this.uploadGeneralImages(res.tempFilePaths)
        } else {
          console.error('没有选择到图片文件')
          wx.showToast({
            title: '没有选择到图片',
            icon: 'none'
          })
        }
      },
      fail: (err) => {
        console.error('选择通用图片失败:', err)
        wx.showToast({
          title: '选择图片失败',
          icon: 'none'
        })
      }
    })
  },

  // 上传通用图片（用于计时报工）
  uploadGeneralImages(tempFilePaths) {
    console.log('开始上传通用图片，文件路径:', tempFilePaths)
    
    if (!tempFilePaths || tempFilePaths.length === 0) {
      console.error('没有文件路径')
      wx.showToast({
        title: '没有选择文件',
        icon: 'none'
      })
      return
    }
    
    wx.showLoading({
      title: '上传中...'
    })

    const uploadPromises = tempFilePaths.map((filePath, index) => {
      return new Promise((resolve, reject) => {
        console.log(`上传第${index + 1}张通用图片:`, filePath)
        
        wx.uploadFile({
          url: app.globalData.baseUrl + '/uploadImage',
          filePath: filePath,
          name: 'file',
          header: {
            'token': wx.getStorageSync('token')
          },
          success: (res) => {
            console.log(`第${index + 1}张通用图片上传响应:`, res)
            try {
              const data = JSON.parse(res.data)
              if (data.code === 1) {
                console.log(`第${index + 1}张通用图片上传成功:`, data.data.url)
                console.log(`本地URL:`, data.data.local_url)
                console.log(`云端URL:`, data.data.cloud_url)
                console.log(`备份信息:`, data.data.backup_info)
                resolve(data.data.url)
              } else {
                console.error(`第${index + 1}张通用图片上传失败:`, data.msg)
                reject(new Error(data.msg))
              }
            } catch (e) {
              console.error(`第${index + 1}张通用图片响应解析失败:`, e, res.data)
              reject(new Error('响应解析失败'))
            }
          },
          fail: (err) => {
            console.error(`第${index + 1}张通用图片上传失败:`, err)
            reject(err)
          }
        })
      })
    })

    Promise.all(uploadPromises).then(imageUrls => {
      console.log('所有通用图片上传成功:', imageUrls)
      
      // 更新通用图片列表
      const images = this.data.images || []
      const newImages = [...images, ...imageUrls]
      
      this.setData({
        images: newImages
      })
      
      console.log('更新后的通用图片列表:', newImages)
      
      wx.hideLoading()
      wx.showToast({
        title: '上传成功',
        icon: 'success'
      })
    }).catch(err => {
      console.error('通用图片上传失败:', err)
      wx.hideLoading()
      wx.showToast({
        title: '上传失败: ' + (err.message || err.errMsg || '未知错误'),
        icon: 'none',
        duration: 3000
      })
    })
  },

  // 删除图片
  deleteImage(e) {
    const itemNo = e.currentTarget.dataset.itemNo
    const index = e.currentTarget.dataset.index
    
    wx.showModal({
      title: '确认删除',
      content: '确定要删除这张图片吗？',
      success: (res) => {
        if (res.confirm) {
          if (itemNo) {
            // 删除产品编号的图片
            const productItems = this.data.productItems
            const itemIndex = productItems.findIndex(item => item.item_no === itemNo)
            
            if (itemIndex !== -1) {
              productItems[itemIndex].images.splice(index, 1)
              productItems[itemIndex].hasImages = productItems[itemIndex].images.length > 0
              
              this.setData({
                productItems: productItems
              })
            }
          } else {
            // 删除通用图片
            const images = this.data.images || []
            images.splice(index, 1)
            this.setData({
              images: images
            })
          }
        }
      }
    })
  },

  // 预览图片
  previewImage(e) {
    const url = e.currentTarget.dataset.url
    wx.previewImage({
      urls: [url],
      current: url
    })
  },

  // 提交主动报工
  submitActiveReport() {
    const { selectedOrder, selectedModel, quantity, workHours, startTime, endTime, workDate, remark, productItems, images } = this.data
    
    if (!selectedOrder) {
      wx.showToast({
        title: '请选择订单',
        icon: 'none'
      })
      return
    }
    
    if (!selectedModel) {
      wx.showToast({
        title: '请选择产品型号和工序',
        icon: 'none'
      })
      return
    }
    
    if (!workDate) {
      wx.showToast({
        title: '请选择工作日期',
        icon: 'none'
      })
      return
    }
    
    if (!quantity || quantity <= 0) {
      wx.showToast({
        title: '请输入数量',
        icon: 'none'
      })
      return
    }
    
    if (!workHours || workHours <= 0) {
      wx.showToast({
        title: '请输入工作时长',
        icon: 'none'
      })
      return
    }

    // 检查计件报工是否所有产品都上传了图片
    if (quantity > 0) { // 只要有数量，就检查产品图片
      const itemsWithoutImages = productItems.filter(item => !item.hasImages)
      if (itemsWithoutImages.length > 0) {
        wx.showToast({
          title: `产品${itemsWithoutImages.map(item => item.item_no).join(',')}还未上传图片`,
          icon: 'none'
        })
        return
      }
    }

    const orderModel = `${selectedModel.model_id}:${selectedModel.process_id}`
    
    const data = {
      order_id: selectedOrder.id,
      order_model: orderModel,
      work_date: workDate,
      remark: remark,
      quantity: quantity,
      work_hours: workHours,
      start_time: startTime,
      end_time: endTime
    }

    // 添加产品编号和图片数据
    if (productItems && productItems.length > 0) {
      data.product_items = productItems.map(item => ({
        item_no: item.item_no,
        images: item.images
      }))
    }

    // 如果有通用图片，也包含进去
    if (images && images.length > 0) {
      data.images = images
    }

    this.setData({
      submitting: true
    })

    app.request({
      url: '/activeReport',
      method: 'POST',
      data: data
    }).then((res) => {
      wx.showToast({
        title: '提交成功',
        icon: 'success'
      })
      
      // 重置表单
      this.setData({
        selectedOrder: null,
        selectedModel: null,
        orderModels: [],
        quantity: '',
        workHours: '',
        startTime: '',
        endTime: '',
        remark: '',
        productItems: [],
        submitting: false
      })
    }).catch((err) => {
      this.setData({
        submitting: false
      })
      wx.showToast({
        title: err.msg || '提交失败',
        icon: 'none'
      })
    })
  }
}) 